{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 深度Q网络\n",
    "\n",
    "只能用于离散动作，异策略训练"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 导入包"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import rl_utils\n",
    "import numpy as np\n",
    "import random\n",
    "import gymnasium as gym\n",
    "import collections\n",
    "import tqdm\n",
    "import torch\n",
    "import torch.nn.functional as F\n",
    "import os"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 经验缓存"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    def __init__(self, capacity):\n",
    "        self.buffer = collections.deque(maxlen=capacity)\n",
    "        \n",
    "    def add(self, state, action, reward, next_state, done, truncated):\n",
    "        self.buffer.append((state, action, reward, next_state, done, truncated))\n",
    "    \n",
    "    def sample(self, batch_size):\n",
    "        transitions = random.sample(self.buffer, batch_size)\n",
    "        state, action, reward, next_state, done, truncated = zip(*transitions)\n",
    "        return np.array(state), action, reward, np.array(next_state), done, truncated  # 多返回了一个state(?)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Q网络"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Qnet(torch.nn.Module):\n",
    "    def __init__(self, state_dim=4, hidden_dim=128, action_dim=2):\n",
    "        super().__init__()\n",
    "        self.fc1 = torch.nn.Linear(state_dim, hidden_dim)\n",
    "        self.fc2 = torch.nn.Linear(hidden_dim, action_dim)\n",
    "    \n",
    "    def forward(self, x):\n",
    "        x = F.elu(self.fc1(x))\n",
    "        x = self.fc2(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 补充/Dueling Q网络"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class VAnet(torch.nn.Module):\n",
    "    ''' 只有一层隐藏层的A网络和V网络 '''\n",
    "    def __init__(self, state_dim, hidden_dim, action_dim):\n",
    "        super(VAnet, self).__init__()\n",
    "        self.fc1 = torch.nn.Linear(state_dim, hidden_dim)  # 共享网络部分\n",
    "        self.fc_A = torch.nn.Linear(hidden_dim, action_dim)\n",
    "        self.fc_V = torch.nn.Linear(hidden_dim, 1)\n",
    "\n",
    "    def forward(self, x):\n",
    "        A = self.fc_A(F.relu(self.fc1(x)))\n",
    "        V = self.fc_V(F.relu(self.fc1(x)))\n",
    "        Q = V + A - A.mean(-1).view(-1, 1)  # Q值由V值和A值计算得到\n",
    "        return Q"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# DQN算法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DQN:\n",
    "    ''' DQN算法 '''\n",
    "    def __init__(self, state_dim, hidden_dim, action_dim, learning_rate, gamma,\n",
    "                 epsilon, target_update, dqn_type, device):\n",
    "        self.action_dim = action_dim\n",
    "        if dqn_type == 'DuelingDQN':  #======># Dueling DQN采取不一样的网络框架\n",
    "            self.q_net = VAnet(state_dim, hidden_dim,\n",
    "                               self.action_dim).to(device)\n",
    "            self.target_q_net = VAnet(state_dim, hidden_dim,\n",
    "                                      self.action_dim).to(device)\n",
    "        else:\n",
    "            self.q_net = Qnet(state_dim, hidden_dim,\n",
    "                              self.action_dim).to(device)\n",
    "            self.target_q_net = Qnet(state_dim, hidden_dim,\n",
    "                                     self.action_dim).to(device)\n",
    "        # 使用Adam优化器\n",
    "        self.optimizer = torch.optim.Adam(self.q_net.parameters(), lr=learning_rate)\n",
    "        self.gamma = gamma  # 折扣因子\n",
    "        self.epsilon = epsilon  # epsilon-贪婪策略\n",
    "        self.target_update = target_update  # 目标网络更新频率\n",
    "        self.count = 0  # 计数器,记录更新次数\n",
    "        self.dqn_type = dqn_type\n",
    "        self.device = device\n",
    "\n",
    "    def take_action(self, state):  # epsilon-贪婪策略采取动作\n",
    "        if np.random.random() < self.epsilon:\n",
    "            action = np.random.randint(self.action_dim)\n",
    "        else:\n",
    "            state = torch.tensor(state[np.newaxis, :], dtype=torch.float).to(self.device)\n",
    "            action = self.q_net(state).argmax().item() # 转成动作序号\n",
    "        return action\n",
    "\n",
    "    def update(self, transition_dict):\n",
    "        states = torch.tensor(transition_dict['states'], dtype=torch.float).to(self.device)\n",
    "        actions = torch.tensor(transition_dict['actions'], dtype=torch.int64).view(-1, 1).to(self.device)\n",
    "        rewards = torch.tensor(transition_dict['rewards'], dtype=torch.float).view(-1, 1).to(self.device)\n",
    "        next_states = torch.tensor(transition_dict['next_states'], dtype=torch.float).to(self.device)\n",
    "        dones = torch.tensor(transition_dict['dones'], dtype=torch.int).view(-1, 1).to(self.device)\n",
    "        truncated = torch.tensor(transition_dict['truncated'], dtype=torch.int).view(-1, 1).to(self.device)\n",
    "\n",
    "        q_values = self.q_net(states).gather(1, actions)  # 模型预测本状态Q值\n",
    "        # 👆 tensor.gather(1, actions) 按行取, 索引为动作序号\n",
    "        if self.dqn_type == 'DoubleDQN' or 'DuelingDQN':  # 先在q网络确定动作, 再对应到目标网络的价值上\n",
    "            max_action = self.q_net(next_states).max(1)[1].view(-1, 1)\n",
    "            max_next_q_values = self.target_q_net(next_states).gather(1, max_action)\n",
    "        else:\n",
    "            max_next_q_values = self.target_q_net(next_states).max(1)[0].view(-1, 1) # 下个状态的最大Q值\n",
    "            # 👆 tensor.max(1)[0], (1)是指按行取最大,(0)按列; [0]是取值,[1]取序号,等于argmax\n",
    "        q_targets = rewards + self.gamma * max_next_q_values * (1 - dones | truncated)  # TD误差目标\n",
    "        dqn_loss = torch.mean(F.mse_loss(q_values, q_targets))  # 均方误差损失函数\n",
    "        self.optimizer.zero_grad()  # 🟠 PyTorch中默认梯度会积累,比如多次求梯度会加总,这里需要显式将梯度置为0\n",
    "        dqn_loss.backward()  # 反向传播更新参数\n",
    "        self.optimizer.step()  # 执行优化\n",
    "\n",
    "        if self.count % self.target_update == 0:\n",
    "            self.target_q_net.load_state_dict(self.q_net.state_dict())  # 更新目标网络\n",
    "        self.count += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 初始化参数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<torch._C.Generator at 0x1aaa7db12b0>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 环境相关\n",
    "env_name = 'CartPole-v1'\n",
    "env = gym.make(env_name, render_mode='rgb_array')\n",
    "\n",
    "# DQN相关\n",
    "total_epoch = 20  # 迭代数\n",
    "s_epoch = 0 # 默认开始位置\n",
    "total_episode = 100  # 每次迭代最大游戏轮数\n",
    "gamma = 0.98\n",
    "epsilon = 1  # 刚开始随机动作,更新中线性降低\n",
    "target_update = 20  # 若干回合更新一次目标网络\n",
    "buffer_size = 10000  # 经验大小\n",
    "minimal_size = 1000  # 最小经验数\n",
    "batch_size = 128\n",
    "best_score = 0  # 每回合中的最佳分数\n",
    "replay_buffer = ReplayBuffer(buffer_size)\n",
    "return_list = []\n",
    "best_weight = 0\n",
    "\n",
    "# 神经网络相关\n",
    "lr = 2e-3\n",
    "hidden_dim = 128\n",
    "state_dim = env.observation_space.shape[0]  # 状态空间大小\n",
    "action_dim = env.action_space.n  # 动作空间大小\n",
    "device = torch.device(\"cuda\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "agent = DQN(state_dim, hidden_dim, action_dim, lr, gamma, epsilon,\n",
    "            target_update, 'DuelingDQN',device)\n",
    "\n",
    "# 随机数种子\n",
    "random.seed(0)\n",
    "np.random.seed(0)\n",
    "torch.manual_seed(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 检查点函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def read_ckp(CKP_PATH):\n",
    "    if os.path.exists(CKP_PATH):\n",
    "        checkpoint = torch.load(CKP_PATH)\n",
    "        s_epoch = checkpoint['epoch']\n",
    "        s_episode = checkpoint['episode']\n",
    "        epsilon = checkpoint['epsilon']\n",
    "        agent.q_net.load_state_dict(checkpoint['best_weight'])\n",
    "        return_list = checkpoint['return_list']\n",
    "        return s_epoch, s_episode, epsilon, return_list\n",
    "    else:\n",
    "        s_epoch = 0\n",
    "        s_episode = 0\n",
    "        epsilon = 1  # 训练时要改的，随意初始化\n",
    "        return_list = []\n",
    "        return s_epoch, s_episode, epsilon, return_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 读取检查点"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "PATH = 'checkpoints/DQN_CPv1_test.pt'\n",
    "s_epoch, s_episode, epsilon, return_list = read_ckp(PATH)\n",
    "replay_buffer = rl_utils.ReplayBuffer(buffer_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for epoch in range(s_epoch, total_epoch):\n",
    "    with tqdm.tqdm(total=total_episode, desc='<%d/%d>'%(epoch+1, total_epoch), leave=False) as pbar:\n",
    "        for episode in range(total_episode):\n",
    "            episode_return = 0\n",
    "            state = env.reset()[0]\n",
    "            done = truncated = False\n",
    "            step = 0\n",
    "            while not done | truncated:\n",
    "                action = agent.take_action(state)\n",
    "                next_state, reward, done, truncated, info = env.step(action)\n",
    "                replay_buffer.add(state, action, reward, next_state, done, truncated)\n",
    "                state = next_state\n",
    "                episode_return += reward\n",
    "                # 当buffer数据的数量超过一定值后,才进行Q网络训练\n",
    "                if len(replay_buffer.buffer) > minimal_size:\n",
    "                    b_s, b_a, b_r, b_ns, b_d, b_t = replay_buffer.sample(batch_size)\n",
    "                    transition_dict = {\n",
    "                        'states': b_s,\n",
    "                        'actions': b_a,\n",
    "                        'next_states': b_ns,\n",
    "                        'rewards': b_r,\n",
    "                        'dones': b_d,\n",
    "                        'truncated': b_t\n",
    "                    }\n",
    "                    agent.update(transition_dict)  # 获得经验中抽取的样本, 拟合网络并且梯度上升\n",
    "                    step += 1 # 步数加一\n",
    "                    \n",
    "                    # 获得最佳权重\n",
    "                    if step > best_score:\n",
    "                        best_weight = agent.q_net.state_dict()\n",
    "                        best_score = step\n",
    "                    \n",
    "            return_list.append(episode_return)\n",
    "            \n",
    "            if (episode + 1) % 10 == 0:  # 显示过去10次游戏情况\n",
    "                pbar.set_postfix({\n",
    "                    'train_times':\n",
    "                    '%d' % (total_episode * epoch + episode + 1),  # 至今一共训练了多少次游戏\n",
    "                    'recent_reward':\n",
    "                    '%.1f' % np.mean(return_list[-10:]),\n",
    "                    'episilon':\n",
    "                    '%.2f' % agent.epsilon\n",
    "                })\n",
    "                \n",
    "            # 调整epsilon\n",
    "            agent.epsilon = max(1 - epoch / (total_epoch / 2), 0.01)\n",
    "            \n",
    "            # 保存检查点\n",
    "            torch.save({\n",
    "                'epoch': epoch,\n",
    "                'episode': episode,\n",
    "                'best_weight': best_weight,\n",
    "                'epsilon': epsilon,\n",
    "                'return_list': return_list,\n",
    "                }, PATH)\n",
    "            pbar.update(1)  # 更新进度条\n",
    "agent.q_net.load_state_dict(best_weight)  # 应用最佳权重"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 作图"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "rl_utils.picture_return(return_list, 'DQN', env_name, 9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                               "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "平均回报:  500.0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[500.0, 500.0, 500.0, 500.0, 500.0, 500.0, 500.0, 500.0, 500.0, 500.0]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rl_utils.show_gym_policy(env_name, agent.q_net, model_type='V')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dueling DQN对比"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 初始化参数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<torch._C.Generator at 0x23886c571d0>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 环境相关\n",
    "PATH = 'checkpoints/ckpt_dueling_dqn_CPv1.pt'\n",
    "env_name = 'CartPole-v1'\n",
    "env = gym.make(env_name, render_mode='rgb_array')\n",
    "\n",
    "# DQN相关\n",
    "total_epoch = 20  # 迭代数\n",
    "s_epoch = 0 # 默认开始位置\n",
    "total_episode = 100  # 每次迭代最大游戏轮数\n",
    "gamma = 0.98\n",
    "epsilon = 1  # 刚开始随机动作,更新中线性降低\n",
    "target_update = 20  # 若干回合更新一次目标网络\n",
    "buffer_size = 10000  # 经验大小\n",
    "minimal_size = 1000  # 最小经验数\n",
    "batch_size = 128\n",
    "best_score = 0  # 每回合中的最佳分数\n",
    "replay_buffer = ReplayBuffer(buffer_size)\n",
    "return_list = []\n",
    "best_weight = 0\n",
    "\n",
    "# 神经网络相关\n",
    "lr = 2e-3\n",
    "hidden_dim = 128\n",
    "state_dim = env.observation_space.shape[0]  # 状态空间大小\n",
    "action_dim = env.action_space.n  # 动作空间大小\n",
    "device = torch.device(\"cuda\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "print('device: ', device)\n",
    "agent = DQN(state_dim, hidden_dim, action_dim, lr, gamma, epsilon,\n",
    "            target_update, 'DuelingDQN',device)\n",
    "\n",
    "# 随机数种子\n",
    "random.seed(0)\n",
    "np.random.seed(0)\n",
    "torch.manual_seed(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 读取检查点"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "PATH = 'checkpoints/ckpt_dqn_PDv1.pt'  # ! 迁移部署后按情况修改, 若已修改, 去掉叹号\n",
    "s_epoch, s_episode, epsilon, return_list = read_ckp(PATH)\n",
    "replay_buffer = rl_utils.ReplayBuffer(buffer_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                                                \r"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "for epoch in range(s_epoch, total_epoch):\n",
    "    with tqdm.tqdm(total=total_episode, desc='<%d/%d>'%(epoch+1, total_epoch), leave=False) as pbar:\n",
    "        for episode in range(total_episode):\n",
    "            episode_return = 0\n",
    "            state = env.reset()[0]\n",
    "            done = truncated = False\n",
    "            step = 0\n",
    "            while not done | truncated: \n",
    "                action = agent.take_action(state)\n",
    "                next_state, reward, done, truncated, info = env.step(action)\n",
    "                replay_buffer.add(state, action, reward, next_state, done, truncated)\n",
    "                state = next_state\n",
    "                episode_return += reward\n",
    "                # 当buffer数据的数量超过一定值后,才进行Q网络训练\n",
    "                if len(replay_buffer.buffer) > minimal_size:\n",
    "                    b_s, b_a, b_r, b_ns, b_d, b_t = replay_buffer.sample(batch_size)\n",
    "                    transition_dict = {\n",
    "                        'states': b_s,\n",
    "                        'actions': b_a,\n",
    "                        'next_states': b_ns,\n",
    "                        'rewards': b_r,\n",
    "                        'dones': b_d,\n",
    "                        'truncated': b_t\n",
    "                    }\n",
    "                    agent.update(transition_dict)  # 获得经验中抽取的样本, 拟合网络并且梯度上升\n",
    "                    step += 1 # 步数加一\n",
    "                    \n",
    "                    # 获得最佳权重\n",
    "                    if step > best_score:\n",
    "                        best_weight = agent.q_net.state_dict()\n",
    "                        best_score = step\n",
    "                    \n",
    "            return_list.append(episode_return)\n",
    "            \n",
    "            if (episode + 1) % 10 == 0:  # 显示过去10次游戏情况\n",
    "                pbar.set_postfix({\n",
    "                    'train_times':\n",
    "                    '%d' % (total_episode * epoch + episode + 1),  # 至今一共训练了多少次游戏\n",
    "                    'recent_reward':\n",
    "                    '%.1f' % np.mean(return_list[-10:]),\n",
    "                    'episilon':\n",
    "                    '%.2f' % agent.epsilon\n",
    "                })\n",
    "                \n",
    "            # 调整epsilon\n",
    "            agent.epsilon = max(1 - epoch / (total_epoch / 2), 0.01)\n",
    "            \n",
    "            # 保存检查点\n",
    "            torch.save({\n",
    "                'epoch': epoch,\n",
    "                'episode': episode,\n",
    "                'best_weight': best_weight,\n",
    "                'epsilon': epsilon,\n",
    "                'return_list': return_list,\n",
    "                }, PATH)\n",
    "            \n",
    "            pbar.update(1)  # 更新进度条\n",
    "agent.q_net.load_state_dict(best_weight)  # 应用最佳权重"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 作图"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "rl_utils.picture_reward(return_list, 'Dueling DQN', env_name, 9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.6"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
